/**
 * CSV数据分析工具
 * 使用Papa Parse对CSV进行统计分析
 */

const fs = require('fs');
const Papa = require('papaparse');

/**
 * 分析CSV文件的统计信息
 * @param {string} filePath - CSV文件路径
 * @param {number} sampleSize - 采样大小
 */
function analyzeCSV(filePath, sampleSize = 10000) {
    return new Promise((resolve, reject) => {
        console.log(`分析文件: ${filePath}`);
        console.log(`采样大小: ${sampleSize} 行`);
        console.log('-'.repeat(50));

        let rowCount = 0;
        const stats = {
            totalRows: 0,
            columns: [],
            columnTypes: {},
            columnStats: {},
            missingValues: {},
            sampleData: []
        };

        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });

        Papa.parse(stream, {
            header: true,
            dynamicTyping: false, // 保持原始类型用于分析
            skipEmptyLines: true,
            
            step: function(result, parser) {
                rowCount++;

                // 初始化列信息
                if (rowCount === 1 && result.meta.fields) {
                    stats.columns = result.meta.fields;
                    
                    result.meta.fields.forEach(col => {
                        stats.columnStats[col] = {
                            numeric: [],
                            text: [],
                            empty: 0
                        };
                        stats.missingValues[col] = 0;
                        stats.columnTypes[col] = 'unknown';
                    });
                }

                // 收集样本数据
                if (rowCount <= sampleSize) {
                    stats.sampleData.push(result.data);

                    // 分析每一列
                    stats.columns.forEach(col => {
                        const value = result.data[col];

                        if (value === null || value === undefined || value === '') {
                            stats.missingValues[col]++;
                            stats.columnStats[col].empty++;
                        } else {
                            // 尝试判断数据类型
                            const numValue = parseFloat(value);
                            if (!isNaN(numValue)) {
                                stats.columnStats[col].numeric.push(numValue);
                            } else {
                                stats.columnStats[col].text.push(value);
                            }
                        }
                    });
                } else {
                    // 超过采样大小后停止解析
                    parser.abort();
                }

                if (rowCount % 1000 === 0) {
                    process.stdout.write(`\r已分析: ${rowCount} 行`);
                }
            },

            complete: function() {
                stats.totalRows = rowCount;
                console.log('\n');

                // 确定列类型
                stats.columns.forEach(col => {
                    const colStats = stats.columnStats[col];
                    if (colStats.numeric.length > colStats.text.length) {
                        stats.columnTypes[col] = 'numeric';
                    } else if (colStats.text.length > 0) {
                        stats.columnTypes[col] = 'text';
                    }
                });

                // 显示分析结果
                displayAnalysisResults(stats, sampleSize);

                resolve(stats);
            },

            error: function(error) {
                console.error('分析错误:', error);
                reject(error);
            }
        });
    });
}

/**
 * 显示分析结果
 */
function displayAnalysisResults(stats, sampleSize) {
    console.log('='.repeat(50));
    console.log('分析结果');
    console.log('='.repeat(50));

    console.log(`\n基本信息:`);
    console.log(`  - 分析行数: ${stats.totalRows.toLocaleString()}`);
    console.log(`  - 总列数: ${stats.columns.length}`);

    console.log(`\n列信息:`);
    stats.columns.forEach((col, idx) => {
        const type = stats.columnTypes[col];
        const missing = stats.missingValues[col];
        const missingPercent = ((missing / stats.totalRows) * 100).toFixed(2);
        
        console.log(`  ${idx + 1}. ${col}`);
        console.log(`     类型: ${type}`);
        console.log(`     缺失值: ${missing} (${missingPercent}%)`);
        
        // 如果是数值类型，显示统计信息
        if (type === 'numeric' && stats.columnStats[col].numeric.length > 0) {
            const numbers = stats.columnStats[col].numeric;
            const min = Math.min(...numbers);
            const max = Math.max(...numbers);
            const avg = numbers.reduce((a, b) => a + b, 0) / numbers.length;
            
            console.log(`     最小值: ${min.toFixed(2)}`);
            console.log(`     最大值: ${max.toFixed(2)}`);
            console.log(`     平均值: ${avg.toFixed(2)}`);
        }
        
        console.log('');
    });

    console.log(`缺失值汇总:`);
    const missingCols = Object.entries(stats.missingValues)
        .filter(([col, count]) => count > 0)
        .sort((a, b) => b[1] - a[1]);
    
    if (missingCols.length > 0) {
        missingCols.forEach(([col, count]) => {
            const percent = ((count / stats.totalRows) * 100).toFixed(2);
            console.log(`  - ${col}: ${count} (${percent}%)`);
        });
    } else {
        console.log(`  没有缺失值`);
    }

    console.log(`\n样本数据 (前5行):`);
    console.table(stats.sampleData.slice(0, 5));
}

/**
 * 数据质量检查
 */
function dataQualityCheck(filePath, checks = {}) {
    return new Promise((resolve, reject) => {
        console.log('执行数据质量检查...');
        
        const issues = {
            duplicates: [],
            outliers: [],
            invalidFormats: [],
            inconsistencies: []
        };

        let rowCount = 0;
        const seenRows = new Set();

        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });

        Papa.parse(stream, {
            header: true,
            skipEmptyLines: true,
            
            step: function(result, parser) {
                rowCount++;

                // 检查重复行
                const rowKey = JSON.stringify(result.data);
                if (seenRows.has(rowKey)) {
                    issues.duplicates.push(rowCount);
                } else {
                    seenRows.add(rowKey);
                }

                // 这里可以添加更多质量检查
                // 例如: 格式验证、范围检查等

                if (rowCount >= 10000) {
                    parser.abort(); // 限制检查范围
                }
            },

            complete: function() {
                console.log('\n数据质量检查结果:');
                console.log(`  - 检查行数: ${rowCount.toLocaleString()}`);
                console.log(`  - 重复行: ${issues.duplicates.length}`);
                console.log(`  - 异常值: ${issues.outliers.length}`);
                console.log(`  - 格式错误: ${issues.invalidFormats.length}`);

                resolve(issues);
            },

            error: reject
        });
    });
}

/**
 * 主函数
 */
async function main() {
    const csvFiles = [
        'output/基本设施.csv',
        'output/设施集合.csv'
    ];

    console.log('='.repeat(50));
    console.log('CSV 数据分析工具');
    console.log('='.repeat(50));

    console.log('\n可用的CSV文件:');
    csvFiles.forEach((file, idx) => {
        try {
            const stats = fs.statSync(file);
            const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
            console.log(`${idx + 1}. ${file} (${sizeMB} MB)`);
        } catch (e) {
            console.log(`${idx + 1}. ${file} (文件不存在)`);
        }
    });

    console.log('\n开始分析第一个文件...\n');

    try {
        // 分析第一个文件
        await analyzeCSV(csvFiles[0], 10000);
        
        console.log('\n分析完成！');
        
    } catch (error) {
        console.error('分析失败:', error);
    }
}

// 如果直接运行此脚本
if (require.main === module) {
    main();
}

module.exports = {
    analyzeCSV,
    dataQualityCheck
};

